#ifdef SS_USE_WINDOWS
#include <vld.h>
#endif
#include <iostream>
#include <set>
#include "ssSingleton.h"
#include "container/ssBuffer.h"
#include "container/ssMultiLineBuffer.h"
#include "container/ssArray.h"
#include "string/ssString.h"
#include "net/ssSimpleHttp.h"
//#include "container/rbTree/ssRBTree.h"
#include "container/ssSet.h"
#include "container/ssMap.h"
#include "thread/ssMsgThread.h"
#include "log/ssLog.h"
#include "log/ssLogger.h"
#include "file/ssReadini.h"
#include "file/ssWriteFile.h"
#include "tools/ssProcessInfo.h"
#include "time/timerThread/ssTimerThread.h"
#include "time/ssTime.h"
#include "ssTimerMessage.h"
#include "container/ssFunction.h"
#include "container/ssQueue.h"
#include "memory/ssAutoPtr.h"
#include "memory/ssTempPtr.h"
#include "dump/ssException.h"
#include "dump/ssDump.h"
#include "ssTestThread.h"
#include "ssTestMsgThread2.h"
#include "ssTestMsgThread3.h"
#include "thread/threadLock/ssAtomic.h"
#include "thread/threadLock/ssAtomicLock.h"
#include "container/ssHeap.h"
#include "string/ssCharCoding.h"
#include "algorithms/base64.h"
#include "algorithms/ssKMP.h"
#include "memory/ssDoublyList.h"
#include "memory/ssMalloc.h"
#include "memory/ssMallocObject.h"
//#include "memory/ssPool.h"
#include "container/ssAny.h"
#include "testCfg.h"
#include "container/stdDictionary.h"
#include "container/ssDictionary.h"
#include "container/ssAsciiDictionary.h"
#include "algorithms/md5.h"
#include "container/ssHashmap.h"
#include "algorithms/ssAStar.h"
#include "byteStream/ssWriteBytes.h"
#include "thread/threadPool/ssThreadPool.h"
#include "mysqlCfg.h"
#include "file/ssPath.h"

using namespace std;
using namespace StarSeeker;

class AA
{
public:
	AA()
	{
		m_id = 0;
		m_str = new char[128];
		cout << "构造AA!" << endl;
	}
	AA(const AA& aa)
	{
		m_id = aa.m_id;
		m_str = new char[128];
		cout << "拷贝构造AA!" << endl;
	}
	~AA()
	{
		m_id = 0;
		delete[] m_str;
		m_str = 0;
		cout << "析构AA" << endl;
	}
	void operator= (const AA& aa)
	{
		m_id = aa.m_id;
		cout << "等号重载AA" << endl;
	}
	bool operator< (const AA& aa) const
	{
		return m_id < aa.m_id;
	}
	bool operator> (const AA& aa) const
	{
		return m_id > aa.m_id;
	}
	void Print()
	{
		cout << "PA!" << endl;
	}
	void dump()
	{
		SS_THROW("FCUK!");
	}

	int m_id;
	char* m_str;
};
void Print()
{
	cout << "Hello world!" << endl;
}

class BB
{
	SS_SINGLETON(BB)
private:
	BB()
	{
		m_id = 0;
		cout << "BB!" << endl;
	}
public:
	int m_id;
};
SS_SINGLETON_INIT(BB)

#ifdef SS_USE_WINDOWS
u32 WINAPI ThreadFunc(void* param)
#else
void* ThreadFunc(void* param)
#endif
{
	cout << "ThreadFunc Run!" << endl;
	return 0;
}

int test_atomic_thread_count = 0;
ssAtomicLock test_atomic_lock;

int main()
{
    //CreateDumpFile();

	srand(time(0));

	{
		ssThread testThread;
		testThread.StartThread(ThreadFunc);
	}

	{
		StarSeeker::ssSingle<AA>::instance()->Print();
		AA* paa = StarSeeker::ssSingle<AA>::instance();
		AA* paa2 = StarSeeker::ssSingle<AA>::instance();
		//    *paa = *paa2;
		typedef void(*gPrint)();
		typedef void(AA::*mPrint)();
		StarSeeker::ssFunc<gPrint> f1(Print);
		SS_FUNC(f1)();
		StarSeeker::ssFunc<mPrint, AA> f2(&AA::Print, paa);
		SS_CLASS_FUNC(f2)();

		BB::instance()->m_id = 110;

		SS_EXP_TRY
			StarSeeker::ssSingle<AA>::instance()->dump();
		SS_EXP_CATCH
			cout << err.GetErrorMsg()<< endl << err.GetStackTrace() << endl;
		SS_EXP_END

		StarSeeker::ssSingle<AA>::delete_instance();
		BB::delete_instance();
	}

//	LoadSocketLib();
//	ssSimpleHttp htp(1024*512);
//	htp.QueryHtml("119.75.220.12", 80, "/");
//	htp.Print();

//{//日志
//	ssLog log(0, "./log1");
//	log.Print("主线程打印 ");
//	log.PrintEx("主线程打印 %s", "2222222");
//
//	SS_LOG->StartThread();
//	SS_LOG->PrintEx("打印线程 %s", "666666");
//}
//{//数组
//	int ia[4] = {0};
//	ssArray<int> iarray;
//	//iarray.Init(5, true);
//	iarray.CopyFrom(ia, 4);
//	int tmp = 1;
//	iarray.PushBack(tmp);
//	tmp = 2;
//	iarray.PushBack(tmp);
//	tmp = 3;
//	iarray.PushBack(tmp);
//	tmp = 4;
//	iarray.PushBack(tmp);
//	tmp = 5;
//	iarray.PushBack(tmp);
//	tmp = 6;
//	iarray.PushBack(tmp);
////	iarray.Empty();
//	ssArray<int,10> iarray2;
//	for(u32 i=0; i<iarray.Count(); ++i)
//	{
//		cout << iarray[i] << endl;
//	}
//}
//{//数字数组
//	int ia[4] = {0};
//	ssNumArray<int> iarray;
//	//iarray.Init(5, true);
//	iarray.CopyFrom(ia, 4);
//	int tmp = 1;
//	iarray.PushBack(tmp);
//	tmp = 2;
//	iarray.PushBack(tmp);
//	tmp = 3;
//	iarray.PushBack(tmp);
//	tmp = 4;
//	iarray.PushBack(tmp);
//	tmp = 5;
//	iarray.PushBack(tmp);
//	tmp = 6;
//	iarray.PushBack(tmp);
////	iarray.Empty();
//	ssNumArray<int,10> iarray2;
//	for(u32 i=0; i<iarray.Count(); ++i)
//	{
//		cout << iarray[i] << endl;
//	}
//	iarray.Remove(1);
//	iarray.Remove(6);
//}

//{//双向链表基类
//	ssDoublyList<sizeof(u32)> dl;
//	for(u32 i=0; i<100; ++i)
//	{
//		*(u32*)dl.Allot() = i;
//	}
//	ssDoublyList<sizeof(u32)>::Node_s* itr_il = dl.Begin();
//	while(itr_il)
//	{
//		if(*(u32*)itr_il->Data()%2==0)
//		{
//			itr_il = dl.EraseNode(itr_il);
//		}
//		else
//		{
//			itr_il = itr_il->Next();
//		}
//	}
//	itr_il = dl.Begin();
//	while(itr_il)
//	{
//		cout << *(u32*)itr_il->Data() << ' ';
//		itr_il = itr_il->Next();
//	}
//	cout<<endl<<endl;
//	for(u32 i=0; i<100; ++i)
//	{
//		*(u32*)dl.Allot() = i;
//	}
//	itr_il = dl.Begin();
//	while(itr_il)
//	{
//		cout << *(u32*)itr_il->Data() << ' ';
//		itr_il = itr_il->Next();
//	}
//	cout<<endl<<endl;
//	itr_il = dl.Begin();
//	while(itr_il)
//	{
//		if(*(u32*)itr_il->Data() %2 != 0)
//		{
//			itr_il = dl.EraseNode(itr_il);
//		}
//		else
//		{
//			itr_il = itr_il->Next();
//		}
//	}
//	itr_il = dl.Begin();
//	while(itr_il)
//	{
//		cout << *(u32*)itr_il->Data() << ' ';
//		itr_il = itr_il->Next();
//	}
//	cout<<endl<<endl;
//}

{//链表
	ssList<u32> il;
	for (u32 i = 0; i < 100; ++i)
	{
		il.PushBack(i);
	}
	ssList<u32>::Iterator itr_il = il.Begin();
	while (itr_il.IsVaild())
	{
		if ((*itr_il) % 2 == 0)
		{
			itr_il = il.EraseItr(itr_il);
		}
		else
		{
			++itr_il;
		}
	}
	itr_il = il.Begin();
	while (itr_il.IsVaild())
	{
		cout << (*itr_il) << ' ';
		++itr_il;
	}
	cout << endl << endl;
	for (u32 i = 0; i < 100; ++i)
	{
		il.PushBack(i);
	}
	itr_il = il.Begin();
	while (itr_il.IsVaild())
	{
		cout << (*itr_il) << ' ';
		++itr_il;
	}
	cout << endl << endl;
	itr_il = il.Begin();
	while (itr_il.IsVaild())
	{
		if ((*itr_il) % 2 != 0)
		{
			itr_il = il.EraseItr(itr_il);
		}
		else
		{
			++itr_il;
		}
	}
	itr_il = il.Begin();
	while (itr_il.IsVaild())
	{
		cout << (*itr_il) << ' ';
		++itr_il;
	}
	cout << endl << endl;
	u32 a = 10;
	il.Remove(a);
	itr_il = il.Begin();
	while (itr_il.IsVaild())
	{
		cout << (*itr_il) << ' ';
		++itr_il;
	}
	cout << endl << endl;

	//std::list<AA> va;
	ssList<AA> va;
	AA a1, a2;
	a1.m_id = 666;
	strncpy(a1.m_str, "6666", 100);
	va.PushBack(a1);
	va.PushBack(a2);
	va.Empty();
	//cout << (*va.Begin()).m_str << endl;
}

//{//顺序缓存
//	ssOrderBuffer ob;
//	ob.Init(20);
//	for (u32 i = 0; i < 100; ++i)
//	{
//		u32 size = rand() % 50 + 4;
//		ob.PushBack(&i, size);
//		cout << "ssOrderBuffer.PushBack：" <<i <<" " << size <<endl;
//	}
//	ssOrderBuffer::Iterator itr = ob.Begin();
//	while (itr.IsVaild())
//	{
//		u32* i = (u32*)itr.Data();
//		cout << "ssOrderBuffer.Iterator：" << *i << " " << itr.Length() << endl;
//		ob.Next(itr);
//	}
//	ob.Empty();
//}

//{//字符串
//	ssString sa("223");
//	sa.CopyFrom("12345");
//	sa = "6874";
//	sa += "asdfrbxxd";
//	sa += "qwertyui";
//	sa.Print();
//	ssString sa2;
//	sa2 = sa;
//	sa2.Print();
//	sa2 = "qwertyuiop";
//	sa2.Print();
//	ssString as3;
//	as3.CopyFrom(sa2.GetString(), 5);
//	as3.Print();
//	sa.Format("cd%d,%s", 255, "99999");
//	sa.Print();
//	as3 = "1^12^123^1234^";
//	ssString::StrElements_t list;
//	as3.StringSplit('^', list);
//	for (u32 i = 0; i < list.Count(); ++i)
//	{
//		list[i].Print();
//	}
//	list[0] = "66666";
//	as3 = "1`1^12`12^123`123^1234`1234";
//	ssString::StrElementList_t list2;
//	as3.StringSplit('^', '`', list2);
//	for (u32 i = 0; i < list2.Count(); ++i)
//	{
//		for (u32 j = 0; j < list2[i].Count(); ++j)
//		{
//			list2[i][j].Print();
//		}
//	}
//	list2.PushBack(list);
//	bool err = list2.IsError(&list2[20]);
//	list2.Remove(1);
//	list2.Remove(2);
//
//	int a = 0;
//}
//{//宽字符串
//	ssWString sa(L"223");
//	sa.CopyFrom(L"12345");
//	sa = L"6874";
//	sa += L"asdfrbxxd";
//	sa += L"qwertyui";
//	sa.Print();
//	ssWString sa2;
//	sa2 = sa;
//	sa2.Print();
//	sa2 = L"qwertyuiop";
//	sa2.Print();
//	ssWString as3;
//	as3.CopyFrom(sa2.GetString(), 5);
//	as3.Print();
//	sa.Format(L"cd%d,%s", 255, L"99999");
//	sa.Print();
//	as3 = L"1^12^123^1234^";
//	ssWString::StrElements_t list;
//	as3.StringSplit('^', list);
//	for (u32 i = 0; i < list.Count(); ++i)
//	{
//		list[i].Print();
//	}
//	list[0] = L"66666";
//	as3 = L"1`1^12`12^123`123^1234`1234";
//	ssWString::StrElementList_t list2;
//	as3.StringSplit('^', '`', list2);
//	for (u32 i = 0; i < list2.Count(); ++i)
//	{
//		for (u32 j = 0; j < list2[i].Count(); ++j)
//		{
//			list2[i][j].Print();
//		}
//	}
//	int a = 0;
//}

//{//集合基类
//	cout << "map base:" << endl;
//	ssRBTree<int> mapTree;
//	for (int i = 0; i < 100; ++i)
//	{
//		mapTree.Insert(i);
//	}
//	bool check = mapTree.Check();
//	assert(check);
//	ssArray<ssRBTreeNode<int>*> del;
//	ssRBTreeNode<int>* itr_map = mapTree.Begin();
//	while (itr_map != mapTree.End())
//	{
//		cout << itr_map->GetKey() << ' ';
//		itr_map = mapTree.Next();
//	}
//	cout<<endl;
//	for (int i = 0; i < 100; ++i)
//	{
//		if (i%2!=0)
//		{
//			mapTree.Remove(i);
//		}
//	}
//	itr_map = mapTree.Begin();
//	while (itr_map != mapTree.End())
//	{
//		cout << itr_map->GetKey() << ' ';
//		itr_map = mapTree.Next();
//	}
//	cout << endl;
//	check = mapTree.Check();
//	for (int i = 0; i < 100; ++i)
//	{
//		mapTree.Insert(i);
//	}
//	itr_map = mapTree.Begin();
//	while (itr_map != mapTree.End())
//	{
//		cout << itr_map->GetKey() << ' ';
//		itr_map = mapTree.Next();
//	}
//	cout << endl;
//	check = mapTree.Check();
//
//	ssRBTree<int> mapTree2;
//	mapTree2 = mapTree;
//	itr_map = mapTree2.Begin();
//	while (itr_map != mapTree2.End())
//	{
//		cout << itr_map->GetKey() << ' ';
//		itr_map = mapTree2.Next();
//	}
//	cout << endl;
//	check = mapTree2.Check();
//}
//{//set
//	cout << "set:" << endl;
//	SS_SET_O(AA) mapTree;
//	std::set<AA> stdTree;
//	for (int i = 0; i < 100000; ++i)
//	{
//		int tmp = rand() % 1000000;
//		AA aa; aa.m_id = tmp;
//		mapTree.Insert(aa);
//		stdTree.insert(aa);
//	}
//	bool check = mapTree.Check();
//	assert(check);
//
//	//ssArray<ssRBTreeNode<int>*> del;
//
//	SS_SET_O(AA)::Iterator itr_map = mapTree.Begin();
//	std::set<AA>::iterator itr_std = stdTree.begin();
// 	while (itr_map != mapTree.End() && itr_std != stdTree.end())
//	{
//		assert((*itr_map).m_id == (*itr_std).m_id);
//		++itr_map;
//		++itr_std;
//	}
//	assert(itr_map == mapTree.End() && itr_std == stdTree.end());
//}
{//map
	cout << "map:" << endl;
	SS_MAP_N(int, int) mapTree;
	for (int i = 0; i < 100; ++i)
	{
		//int r = rand() % 100000;
		mapTree.Insert(i,i);
	}
	bool check = mapTree.Check();
	assert(check);
	ssArray<ssRBTreeNode<int>*> del;
	SS_MAP_N(int, int)::Iterator itr_map = mapTree.Begin();
	while (itr_map != mapTree.End())
	{
		cout << itr_map.Second() << ' ';
		++itr_map;
	}
	cout << endl;
	for (int i = 0; i < 100; ++i)
	{
		if (i % 2 != 0)
		{
			mapTree.Erase(i);

			cout << i << "::";
			itr_map = mapTree.Begin();
			while (itr_map != mapTree.End())
			{
				cout << itr_map.Second() << ' ';
				++itr_map;
			}
			cout << endl;
			check = mapTree.Check();
		}
	}
	//itr_map = mapTree.Begin();
	//while (itr_map != mapTree.End())
	//{
	//	cout << itr_map.Second() << ' ';
	//	++itr_map;
	//}
	//cout << endl;
	//check = mapTree.Check();
	for (int i = 0; i < 100; ++i)
	{
		mapTree.InsertCover(i,i);
	}
	itr_map = mapTree.Begin();
	while (itr_map != mapTree.End())
	{
		cout << itr_map.Second() << ' ';
		++itr_map;
	}
	cout << endl;
	check = mapTree.Check();
	for (int i = 100; i < 200; ++i)
	{
		mapTree[i] = i;
	}
	itr_map = mapTree.Begin();
	while (itr_map != mapTree.End())
	{
		cout << itr_map.Second() << ' ';
		++itr_map;
	}
	cout << endl;
	check = mapTree.Check();

	SS_MAP_N(int, int) mapTree2;
	mapTree2 = mapTree;
	itr_map = mapTree2.Begin();
	while (itr_map != mapTree2.End())
	{
		cout << itr_map.Second() << ' ';
		++itr_map;
	}
	cout << endl;
	check = mapTree2.Check();
}

{//any
	ssAny a1 = 1123;
	ssAny a2 = 14.56f;
	cout << "a1:" << a1.Clone<int>() << "   " << a1.GetType() << endl;
	cout << "a2:" << *a2.Get<float>() << "   " << a2.GetType() << endl;
}

//{//线程
//	ssMsgThreadBase th1;
//	th1.SetMaxMsgCount(30);
//	th1.StartThread();
//	ssMsg_s m(100,0);
//	for (int i=0;i<50;++i)
//	{
//		m.msgID = 100+i;
//		th1.PostMsg(m);
//	}
//	ssThreadBase::Sleep(3000);
//}

//{//日志
//	ssLogger log;
//	log.StartThread();
//
//	for (int i=0;i<10;++i)
//	{
//		log.PrintEx("log:%d", i);
//	}
//	log.Print("log:sssssssssssssssssssss");
//
//	ssThreadBase::Sleep(3000);
//}

//{//ini
//	ssReadini ini;
//	if(ini.Open("./test.ini"))
//	{
//		printf("%s, %s, %d\n", ini.GetString("config", "ip", "abc").c_str(), ini.GetString("config", "port", "abc").c_str(), ini.Getint("config", "num", 9999));
//	}
//}

//{//写文件
//	ssWriteFile wf;
//	wf.Init("./11.txt");
//	wf.WriteStringWithTime("qqqqqqqqqqqq\n");
//	wf.WriteStringWithTime("wwwwwwwwwwww\n");
//	wf.WriteBytes("eeeeeeeeee\n", 11);
//
//	ssWriteFile wf2;
//	wf2.Init("./12.txt", true, false);
//	wf2.WriteStringWithTime("qqqqqqqqqqqq\r\n");
//	wf2.WriteStringWithTime("wwwwwwwwwwww\r\n");
//	wf2.WriteBytes("eeeeeeeeee\r\n", 12);
//
//	ssWriteFile wf3;
//	wf2.Init("./13.txt");
//	wf2.OpenFile();
//	wf2.Stream()<<"qqqqqqqqqqqq"<<std::endl;
//	wf2.Stream()<<99541.21f<<std::endl;
//	wf2.CloseFile();
//	wf2.OpenFile();
//	wf2.Stream()<<"wwwwwwwwwwww"<<std::endl;
//	wf2.Stream()<<3.1415926<<std::endl;
//	wf2.CloseFile();
//}

//{ //stl分配器
	//SS_VECTOR(int) intVec(5);
	//intVec.push_back(112);
	//intVec.push_back(113);
	//cout << intVec[5] << endl;
	//cout << intVec[6] << endl;

	//SS_SET(long) myset;
	//myset.insert(123);
	//myset.insert(1234);
	//for(SS_SET(long)::iterator it=myset.begin(); it!=myset.end(); ++it)
	//{
	//	cout << (*it) << endl;
	//}
//}

{//创建文件夹
	std::string ext = ssPath::ExtName("./asfas/sdffeeee/aas.txt");
	std::string name = ssPath::BaseName("./asfas/sdffeeee/aas.txt");
	std::string name2 = ssPath::BaseName("./asfas/sdffeeee/aas.txt", false);
	std::string path = ssPath::RemoveFileName("./asfas/sdffeeee/aas.txt");
	ssPath::MakeDir("./abc1/abc2/abc3");
}

{//进程信息
	ssProcess::instance()->GetInfo();
	cout << ssProcess::instance()->m_fullPath.GetString() << endl
		<< ssProcess::instance()->m_path.GetString() << endl
		<< ssProcess::instance()->m_name.GetString() << endl
		<< ssProcess::instance()->GetNameRemoveExt().GetString() << endl
		<< ssProcess::instance()->m_resPath.GetString() << endl;
	std::string res = ssProcess::instance()->GetResPath("sddfffd.txt").GetString();
	cout<<res<<endl;
	ssProcess::delete_instance();
}

//{//计时器线程
	ssTimerMessage * pDispatch = new ssTimerMessage;
	ssTimerThread * pTimerThread = new ssTimerThread;
	pTimerThread->BindDispatch(pDispatch);
	pTimerThread->StartThread();
	ssThreadBase::Sleep(1000);
	pTimerThread->AddNewTimer(SS_TIMER_ONCE, 30, 123, 0);
	ssThreadBase::Sleep(1000);
	pTimerThread->AddNewTimer(SS_TIMER_ONCE, 40, 124, 0);
	ssThreadBase::Sleep(1000);
	pTimerThread->AddNewTimer(SS_TIMER_ONCE, 50, 125, 0);
	ssThreadBase::Sleep(1000);
	pTimerThread->AddNewTimer(SS_TIMER_ONCE, 60, 126, 0);
	pTimerThread->StartHalfTimer();

	int ct = 0;
	while (ct++<5)
	{
		ssThreadBase::Sleep(1000);
	}
	delete pTimerThread;
	delete pDispatch;
//}

{//消息线程
	//ssTestMsgThread* testMsg = new ssTestMsgThread(0);
	//testMsg->StartThread();
	//ssThreadBase::Sleep(500);
	//ssTestThread* test1 = new ssTestThread(1, testMsg);
	//test1->StartThread();
	//ssThreadBase::Sleep(500);
	//ssTestThread* test2 = new ssTestThread(2, testMsg);
	//test2->StartThread();
	//ssThreadBase::Sleep(500);
	//ssTestThread* test3 = new ssTestThread(3, testMsg);
	//test3->StartThread();
 //   ssThreadBase::Sleep(500);
	//ssTestThread* test4 = new ssTestThread(4, testMsg);
	//test4->StartThread();
 //   ssThreadBase::Sleep(500);
	//ssTestThread* test5 = new ssTestThread(5, testMsg);
	//test5->StartThread();
 //   ssThreadBase::Sleep(500);
	//ssTestThread* test6 = new ssTestThread(6, testMsg);
	//test6->StartThread();


	//ssTestMsgThread2* testMsg2 = new ssTestMsgThread2(2);
	//ssTestMsgThread3* testMsg3 = new ssTestMsgThread3(3);
	//testMsg2->SetMaxMsgCount(10);
	//testMsg2->SetThread(testMsg3);
	//testMsg3->SetMaxMsgCount(10);
	//testMsg3->SetThread(testMsg2);

	//testMsg3->StartThread();
	//ssThreadBase::Sleep(500);
	//testMsg2->StartThread();
	//ssThreadBase::Sleep(500);

	//ssTestThread* test1 = new ssTestThread(1, testMsg2);
	//test1->StartThread();

	//while (1)
	//	ssThreadBase::Sleep(1);
}

//{//对象池
//	ssMutexMallocObj<int> pool;
//	int* arr[2000] = {0};
//	for (int i=0; i<1000; ++i)
//	{
//		arr[i] = pool.Malloc();
//		*(arr[i]) = i;
//	}
//	for (int i=0; i<1000; ++i)
//	{
//		printf("%d ", *(arr[i]));
//	}
//	printf("\n\n");
//	for (int i=0; i<1000; ++i)
//	{
//		if (*(arr[i])%2==0)
//		{
//			pool.Free(arr[i]);
//			arr[i] = 0;
//		}
//	}
//	for (int i=0; i<1000; ++i)
//	{
//		if (arr[i])
//		{
//			printf("%d ", *(arr[i]));
//		}
//	}
//	printf("\n\n");
//	pool.Release();
//	for (int i=0; i<1500; ++i)
//	{
//		if (arr[i]==0)
//		{
//			arr[i] = pool.Malloc();
//			*(arr[i]) = i+5000;
//		}
//	}
//	for (int i=0; i<1000; ++i)
//	{
//		if (arr[i])
//		{
//			printf("%d ", *(arr[i]));
//		}
//	}
//	printf("\n\n");
//}

{//队列
	//ssQueue<int> que;
	//for (int i=0; i<100; ++i)
	//{
	//	que.Push(i);
	//}
	//ssQueue<int>::Iterator itr = que.Begin();
	//while (itr!=que.End())
	//{
	//	cout<< *itr <<' ';
	//	++itr;
	//}
	//cout<<'('<<que.Count()<<'|'<<que.TotalCount()<<')'<<endl;
//
//	for (int i=0; i<50; ++i)
//	{
//		que.Pop();
//	}
//	itr = que.Begin();
//	while (itr!=que.End())
//	{
//		cout<< *itr <<' ';
//		++itr;
//	}
//	cout<<'('<<que.Count()<<'|'<<que.NodeCount()<<')'<<endl;
//
//	for (int i=200; i<230; ++i)
//	{
//		que.Push(i);
//	}
//	itr = que.Begin();
//	while (itr!=que.End())
//	{
//		cout<< *itr <<' ';
//		++itr;
//	}
//	cout<<'('<<que.Count()<<'|'<<que.NodeCount()<<')'<<endl;
//
//	que.Empty();
//
//	for (int i=1000; i<1120; ++i)
//	{
//		que.Push(i);
//	}
//	itr = que.Begin();
//	while (itr!=que.End())
//	{
//		cout<< *itr <<' ';
//		++itr;
//	}
//	cout<<'('<<que.Count()<<'|'<<que.NodeCount()<<')'<<endl;
//
//	while (que.Pop())
//	{
//	}
//	cout<<'('<<que.Count()<<'|'<<que.NodeCount()<<')'<<endl;
}

{//智能指针
	ssTempPtr<AA> up1(new AA);
	//ssTempPtr<AA> sp2 = up1;
	up1->Print();
	ssTempArrPtr<AA> up2(5);
	up2[0].Print();

	ssAutoPtr<AA> p1 = new AA;
	p1->m_id = 110;
	strcpy(p1->m_str, "120");

	ssAutoPtr<AA> p2 = p1;
	ssAutoPtr<AA> p3 = p2;
	ssAutoPtr<AA> p4;
	p4 = p2;
	//p4 = new AA;
	p4 = p3;
}

//{//内存池
//	ssPool pool;
//	pool.Init(1024*100);
//	cout<< pool.PrintChunk() <<endl;
//
//	u32 len[50];
//	int* add[50];
//	for (u32 i=0; i<50; ++i)
//	{
//		len[i] = rand()%150+11;
//		add[i] = (int*)pool.Malloc(len[i]);
//	}
//	cout<< pool.PrintChunk() <<endl;
//	for (u32 i=0;i<50;++i)
//	{
//		if (len[i]<100)
//		{
//			pool.Free(add[i]);
//			add[i] = 0;
//		}
//	}
//	cout<< pool.PrintChunk() <<endl;
//}

//{//时间
//	char t[SS_TIME_STR_LEN] = { 0 };
//	ssTime::GetLocalTime(t);
//	cout << t << endl;
//
//	ssTimeYMDHMS y;
//	ssTime::GetLocalTime(ssTime::GetTodayZero(), y);
//
//	ssTimeYMDHMS ttt;
//	ttt.Zero();
//	ttt.year.i32p = 2017;
//	ttt.month.i32p = 1;
//	ttt.day.i32p = 1;
//	ttt.hour.i32p = 5;
//	time_t ts = ssTime::GetTimestamp(ttt);
//	ssTime::GetTime(ts, ttt);
//	ssTime::GetLocalTime(ts, ttt);
//}

//{//dump
//	AA aa;
//	aa.dump();
//
//	int a = 5/0;
//}


{//原子操作
	ssAtomicl ac(10);
	++ac;
	--ac;
	ac+=5;
	ac-=5;

	class TestAtomicThread : public ssThreadBase
	{
	private:
		void ThreadMemberFunc()
		{
			for (u32 i = 0; i < 10000000; i++)
			{
				test_atomic_lock.Lock();
				if (m_ThreadId % 2 == 0)
					test_atomic_thread_count += 1;
				else
					test_atomic_thread_count -= 1;
				test_atomic_lock.Unlock();
			}
		}
	};
	TestAtomicThread threads[4];
	for (u32 i = 0; i < 4; ++i)
	{
		threads[i].m_ThreadId = i;
		threads[i].StartThread();
	}
	for (u32 i = 0; i < 4; ++i)
	{
		threads[i].WaitForExit();
	}
	//ssThreadBase::Sleep(5000);
	std::cout << "TestAtomicThread count: "<< test_atomic_thread_count<< std::endl;
}

//{//堆
//	int aa1[10] = { 36, 30, 18, 40, 32, 45, 22, 50 };
//	ssHeap<int> h1(true, aa1, 8);
//	bool ret = h1.CheckHeap();
//	for (u32 i = 0; i < h1.Count(); i++)
//	{
//		cout << h1.Array()[i] << " ";
//	}
//	cout << endl;
//	ssHeap<int> h2(false, aa1, 8);
//	ret = h2.CheckHeap();
//	ssHeap<int> h1_2(true);
//	for (u32 i = 0; i < 8; ++i)
//	{
//		h1_2.Push(aa1[i]);
//	}
//	ret = h1_2.CheckHeap();
//	SS_ASSERT(ret);
//
//	int aa2[10000];
//	for (u32 i = 0; i < 1000; ++i)
//	{
//		aa2[i] = rand() % 1000;
//	}
//	ssHeap<int> h3(true, aa2, 1000);
//	ret = h3.CheckHeap();
//	SS_ASSERT(ret);
//	for (u32 i = 0; i < 50; ++i)
//	{
//		h3.Pop();
//	}
//	ret = h3.CheckHeap();
//	SS_ASSERT(ret);
//	for (u32 i = 0; i < 10000; ++i)
//	{
//		aa2[i] = rand() % 100000;
//	}
//	ssHeap<int> h4(false, aa2, 10000);
//	ret = h4.CheckHeap();
//	SS_ASSERT(ret);
//	for (u32 i = 0; i < 20; ++i)
//	{
//		h4.Pop();
//	}
//	ret = h4.CheckHeap();
//	SS_ASSERT(ret);
//	ssHeap<int> h5(true);
//	for (u32 i = 0; i < 10000; ++i)
//	{
//		aa2[i] = rand() % 100000;
//		h5.Push(aa2[i]);
//	}
//	ret = h5.CheckHeap();
//	SS_ASSERT(ret);
//	for (u32 i = 0; i < 50; ++i)
//	{
//		h5.Pop();
//	}
//	ret = h5.CheckHeap();
//	SS_ASSERT(ret);
//	ssHeap<int> h6(false);
//	for (u32 i = 0; i < 10000; ++i)
//	{
//		aa2[i] = rand() % 100000;
//		h6.Push(aa2[i]);
//	}
//	ret = h6.CheckHeap();
//	SS_ASSERT(ret);
//	for (u32 i = 0; i < 100; ++i)
//	{
//		h6.Pop();
//	}
//	ret = h6.CheckHeap();
//	SS_ASSERT(ret);
//
//	ssHeap<int,10> h7(true);
//}

//{//utf8
//    ssTrieTreeEx<wchar_t>	m_keyTree;
//    ssReadFile rf;
//	rf.SetPath("pbz-utf8.txt");
//	if (rf.OpenFile(false))
//	{
//		std::set<std::wstring> list;
//		while (rf.GetLine(0, 0))
//		{
//			std::string in = rf.GetBuffer().Buf();
//			if (!in.empty())
//			{
//                if(in[in.size()-1]=='\r')
//                    in[in.size()-1] = 0;
//
//				std::wstring out;
//				UTF8_To_UNICODE(in, out);
//				list.insert(out);
//			}
//			if(in=="xijinping")
//			{
//                break;
//			}
//		}
//		for (std::set<std::wstring>::iterator itr = list.begin(); itr != list.end(); ++itr)
//		{
//			m_keyTree.Insert(itr->c_str());
//		}
//        m_keyTree.InitNext();
//		printf("keyword count: %d", list.size());
//		//m_keyTree.Print();
//		std::set<std::wstring>::iterator itr = list.find(L"xijinping");
//		bool fd = itr==list.end();
//		size_t len = 0;
//		int beg = m_keyTree.SearchKeyWord(L"xijinpingx", len);
//		int aaa = 0;
//	}
//}

{//base64
	std::string text = "gebaq31968vzx";
	std::string code = base64_encode((const unsigned char*)text.c_str(), text.size());
	std::string text2 = base64_decode(code);
	cout << text << endl << code << endl << text2 << endl;
}

{//md5
	std::string text = "gebaq31968vzx";
	std::string code = GetMd5(text);
	cout << text << endl << code << endl;
}

{//kmp
	int next[128] = { 0 };
	wchar_t T[] = L"ababxbababcadfdsss";
	wchar_t P[] = L"bxb";
	//MakeNext(P,next,strlen(P));
	int pos = StringMatchingByKmp(T, wcslen(T), P, wcslen(P));
	cout << pos << endl;
}

//{//csv解析
//	testCfg cfg;
//	bool ret = cfg.Read();
//}
{//xml配置解析
	mysqlCfg cfg;
	mysqlCfg::iterator itr;
	cfg.SetPath("dbcfg.xml");
	std::map<i32, mysqlCfgRow>	queryMap;
	if (cfg.Read())
	{
		for (itr = cfg.MapBegin(); itr != cfg.MapEnd(); itr++)
		{
			//m_queryMap[(u32)itr->first] = itr->second;
			u32 id = (u32)itr->first;
			mysqlCfgRow row = itr->second;
			queryMap.insert(std::pair<u32, mysqlCfgRow>(id, row));
		}
		cfg.Clear();
	}
}
//{//字典基类
//	stdTrieTree<char,int> stdTree;
//	ssTrieTree<char, int> ssTree;
//	stdTree.Insert("abcd", 4, new int(123));
//	stdTree.Insert("abca", 4, new int(1234));
//	stdTree.Insert("ynrte", 5, new int(12345));
//	stdTree.Insert("abcdgdse", 8, new int(123456));
//	ssTree.Insert("abcd", 4, new int(123));
//	ssTree.Insert("abca", 4, new int(1234));
//	ssTree.Insert("ynrte", 5, new int(12345));
//	ssTree.Insert("abcdgdse", 8, new int(123456));
//	cout << *stdTree.Find("abcd", 4)->Data() << endl;
//	cout << *stdTree.Find("abca", 4)->Data() << endl;
//	cout << *stdTree.Find("ynrte", 5)->Data() << endl;
//	cout << *stdTree.Find("abcdgdse", 8)->Data() << endl;
//	cout << *ssTree.Find("abcd", 4)->Data() << endl;
//	cout << *ssTree.Find("abca", 4)->Data() << endl;
//	cout << *ssTree.Find("ynrte", 5)->Data() << endl;
//	cout << *ssTree.Find("abcdgdse", 8)->Data() << endl;
//	stdTree.Remove("abca", 4);
//	stdTree.Remove("abcdgdse", 8);
//	ssTree.Remove("abca", 4);
//	ssTree.Remove("abcdgdse", 8);
//	//cout << *stdTree.Find("abcdgdse", 8)->Data() << endl;
//	//cout << *ssTree.Find("abcdgdse", 8)->Data() << endl;
//	stdTree.Empty();
//	ssTree.Empty();
//}
//{//字典容器
//	stdDictionary<char, int> stdTree;
//	ssDictionary<char, int> ssTree;
//	stdTree.Insert("abcd", 4, new int(123));
//	stdTree.Insert("abca", 4, new int(1234));
//	stdTree.Insert("ynrte", 5, new int(12345));
//	stdTree.Insert("abcdgdse", 8, new int(123456));
//	ssTree.Insert("abcd", 4, new int(123));
//	ssTree.Insert("abca", 4, new int(1234));
//	ssTree.Insert("ynrte", 5, new int(12345));
//	ssTree.Insert("abcdgdse", 8, new int(123456));
//	cout << *stdTree.Find("abcd", 4).Data() << endl;
//	cout << *stdTree.Find("abca", 4).Data() << endl;
//	cout << *stdTree.Find("ynrte", 5).Data() << endl;
//	cout << *stdTree.Find("abcdgdse", 8).Data() << endl;
//	cout << *ssTree.Find("abcd", 4).Data() << endl;
//	cout << *ssTree.Find("abca", 4).Data() << endl;
//	cout << *ssTree.Find("ynrte", 5).Data() << endl;
//	cout << *ssTree.Find("abcdgdse", 8).Data() << endl;
//	stdTree.Erase("abca", 4);
//	stdTree.Erase("abcdgdse", 8);
//	ssTree.Erase("abca", 4);
//	ssTree.Erase("abcdgdse", 8);
//	//cout << *stdTree.Find("abcdgdse", 8).Data() << endl;
//	//cout << *ssTree.Find("abcdgdse", 8).Data() << endl;
//	stdTree.Empty();
//	ssTree.Empty();
//}
{//英文字典容器
	ssAsciiDictionary<int> ssTree;
	ssTree.Insert(new int(12), "abcd", 4);
	ssTree.Insert(new int(1234), "abca", 4);
	ssTree.Insert(new int(12345), "ynrte", 5);
	ssTree.Insert(new int(123456), "abcdgdse", 8);

	cout << endl;
	cout << *ssTree.Find("abcd", 4).Data() << endl;
	cout << *ssTree.Find("abca", 4).Data() << endl;
	cout << *ssTree.Find("ynrte", 5).Data() << endl;
	cout << *ssTree.Find("abcdgdse", 8).Data() << endl;
	cout << endl;

	ssAsciiDictionary<int>::Iterator itr = ssTree.Begin();
	while (itr != ssTree.End())
	{
		if (itr.Data())
		{
			cout << *itr.Data() << endl;
		}
		++itr;
	}

	ssTree.Erase("abca", 4);
	ssTree.Erase("abcdgdse", 8);
	//cout << *ssTree.Find("abcdgdse", 8).Data() << endl;

	cout << endl;
	itr = ssTree.Begin();
	while (itr != ssTree.End())
	{
		if (itr.Data())
		{
			cout << *itr.Data() << endl;
		}
		++itr;
	}
	ssTree.Clear();
}
{//哈希表
	ssHashmap<int,int> hm;
	int a = 123;
	hm.Insert(a, a);
	a = 123+16;
	hm.Insert(a, a);
	ssHashmap<ssString, int> hm2;
	hm2.Insert(ssString("256"), a);
	int* ret = hm.Find(123 + 32);
}
{//A星
	char cells[100];
	memset(cells, 1, sizeof(cells));
	cells[36] = 0;
	cells[46] = 0;
	cells[56] = 0;
	cells[66] = 0;

	ssAStar astar;
	astar.Init(10, 10, cells, 100);
	bool ret = astar.PathFinding(6,1,4,7);
	ssNumArray<ulint> out;
	astar.GetResult(out);

	ssThreadBase::Sleep(1);
}
{//写字节缓存
	ssWriteBytes wb;
	wb.Set(128);
}
{//线程池
	class TestWorkThread : public ssWorkThread
	{
	public:
		TestWorkThread(ssThreadPool& pool)
			:ssWorkThread(pool)
		{
		}
	private:
		void HandleMessage(ssMsg_s &m) {
			cout << "TestWorkThread receive msg!" << endl;
		}
	};

	ssThreadPool pool;
	pool.AddThread(new TestWorkThread(pool));
	pool.Start();
	pool.PostMsg(1, 2, 3, 4, 5);
	pool.PostMsg(1, 2, 3, 4, 6);
	pool.PostMsg(1, 2, 3, 4, 7);
	ssThread::Sleep(2000);
	pool.PostMsg(1, 2, 3, 4, 8);
	pool.PostMsg(1, 2, 3, 4, 9);
	pool.PostMsg(1, 2, 3, 4, 10);
	ssThread::Sleep(2000);
}

	//while (true)
	{
		ssThreadBase::Sleep(5000);
	}

	ssCallStack::instance()->delete_instance();
	StarSeeker::ssSingle<StarSeeker::ssLogger>::delete_instance();

    return 0;
}
